/**
 * decodeURIComponent
 * ps: %E8%BF%99%E4%BC%A0%E8%BE%93%E9%85%8D%E7%BD%AE%E7%9A%84%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E8%BD%AC%E6%8D%A2%E6%9C%89%E7%82%B9%E7%83%82%E4%BA%86%EF%BC%8C%E5%A6%82%E6%9E%9C%E8%A6%81%E6%94%B9%EF%BC%8C%E5%BB%BA%E8%AE%AE%E4%BD%A0%E8%AE%A9%E5%90%8E%E7%AB%AF%E5%B7%B4%E6%8A%8A%E7%BB%93%E6%9E%84%E6%94%B9%E6%88%90%E5%92%8C%E6%B7%BB%E5%8A%A0%E8%AE%BE%E5%A4%87%E7%B1%BB%E5%9E%8B%E4%B8%80%E6%A0%B7%E7%9A%84%E7%BB%93%E6%9E%84
 *
 * 赋值时记得深拷贝，避免数据混乱
 */
import deepClone from '@/libs/deepClone'
import useGlobalAPI from '../useGlobalAPI'
import {
  EditDevConConfigOption,
  EditDevConConfigOptionParamConfDataMODBUS,
  EditDevConConfigOptionParamConfJSON,
  EditDevConConfigOptionParamConfMODBUS
} from '@/api/device'
import { message } from '@/libs/global/antDesignVue'

function useDevConConfig() {
  // 设备类型的通信配置
  const defaultDevConConfig: Device.ConConfig = {
    devCCId: undefined,
    devId: undefined,

    devTxTypeCode: '0017',
    devDataTypeCode: '0019',
    devHeart: '',
    paramConfList: []
  }
  let devConConfig = ref<typeof defaultDevConConfig>(deepClone(defaultDevConConfig))
  function setDevConConfig(data: typeof defaultDevConConfig) {
    devConConfig.value = data
  }

  // 设备类型通信组件的通信配置
  const defaultDevTypeModuleConConfig: AddDevType.DevTypeConConfigSign = {
    devTypeCCId: undefined,
    devTypeId: undefined,
    devTypeHeart: '',
    /**通讯类型 MQTT或SOCKET*/
    devTypeTxTypeCode: '0017',
    /**通讯数据格式 JSON或MODBUS */
    devTypeDataTypeCode: '0019',
    txConf: {
      confId: undefined,
      devTypeId: undefined,
      jdtParamConfDesc: '',
      jdtParamConfFlag: '0',
      paramConfDataList: [],
      sort: '0'
    }
  }
  let devTypeModuleConConfig = ref<AddDevType.DevTypeConConfigSign>(
    deepClone(defaultDevTypeModuleConConfig)
  )
  function setdevModuleConConfig(data: AddDevType.DevTypeConConfigSign) {
    devTypeModuleConConfig.value = data
  }

  // 重置配置状态
  function initDevConConfig(option?: {
    initDevConConfig?: boolean
    initdevModuleConConfig?: boolean
  }) {
    devConConfig.value = deepClone(defaultDevConConfig)
    devTypeModuleConConfig.value = deepClone(defaultDevTypeModuleConConfig)
  }

  // -----------------------------------数据类型转换 Device.ConConfig 转为 AddType.DevTypeConConfigSign-----------------------------------
  function devConConfig2devTypeModuleConConfig(
    conConfig: Device.ConConfig,
    isUpdate?: boolean
  ): AddDevType.DevTypeConConfigSign {
    //   // 存储原始数据
    isUpdate !== false && setDevConConfig(deepClone(conConfig) as typeof defaultDevConConfig)

    let devCon: AddDevType.DevTypeConConfigSign = {
      devTypeCCId: conConfig.devCCId,
      devTypeId: conConfig.devId,
      devTypeHeart: conConfig.devHeart,
      devTypeTxTypeCode: conConfig.devTxTypeCode,
      devTypeDataTypeCode: conConfig.devDataTypeCode,
      txConf: {
        devTypeId: undefined,
        jdtParamConfDesc: '',
        confId: undefined,
        jdtParamConfFlag: '1',
        paramConfDataList: [],
        sort: '0'
      }
    }

    if (conConfig.devDataTypeCode === '0019') {
      let txConf = devJSONConf2devTypeModuleJSONTxConf(
        conConfig.paramConfList as Device.ParamConfJSON[]
      )
      if (txConf) {
        devCon.txConf = txConf
      }
    } else {
      devCon.txConf = devMODBUSConf2devTypeModuleMODBUSTxConf(
        conConfig.paramConfList as Device.ParamConfMODBUS[]
      )
    }

    isUpdate !== false &&
      setdevModuleConConfig(deepClone(devCon) as typeof defaultDevTypeModuleConConfig)
    return devCon
  }

  function devJSONConf2devTypeModuleJSONTxConf(
    txConfList: Device.ParamConfJSON[]
  ): AddDevType.TxConf_JSON | undefined {
    if (!txConfList.length) return undefined
    let txConf = txConfList[0]
    let devJSONConf: AddDevType.TxConf_JSON = {
      devTypeId: txConf.devId,
      jdtParamConfDesc: txConf.jdtParamConfDesc,
      confId: txConf.confId,
      jdtParamConfFlag: txConf.jdtParamConfFlag,
      sort: txConf.sort,
      paramConfDataList: txConf.paramConfDataList
    }
    return devJSONConf
  }

  function devMODBUSConf2devTypeModuleMODBUSTxConf(
    txConfList: Device.ParamConfMODBUS[]
  ): AddDevType.TxConf_MODBUS[] {
    let devMODBUSConfList: AddDevType.TxConf_MODBUS[] = []

    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]
      let devModBusConf: AddDevType.TxConf_MODBUS = {
        confId: txConf.confId,
        devTypeId: txConf.devId,
        mdtParamConfDesc: txConf.mdtParamConfDesc,
        addressCode: txConf.addressCode,
        funCode: txConf.funCode,
        sort: txConf.sort,
        paramConfDataList: txConf.paramConfDataList
      }
      devMODBUSConfList.push(devModBusConf)
    }
    return devMODBUSConfList
  }

  //----------------------------------- AddType.DevTypeConConfigSign 转为 Device.ConConfig -----------------------------------
  function devTypeModuleConConfig2devConConfig(
    conConfig: AddDevType.DevTypeConConfigSign
  ): Device.ConConfig {
    let devCon: Device.ConConfig = {
      devCCId: conConfig.devTypeCCId,
      devId: conConfig.devTypeId,
      devHeart: conConfig.devTypeHeart,
      devTxTypeCode: conConfig.devTypeTxTypeCode,
      devDataTypeCode: conConfig.devTypeDataTypeCode,
      paramConfList: []
    }
    if (conConfig.devTypeDataTypeCode === '0019') {
      devCon.paramConfList = devTypeModuleJSONTxConf2devJSONConf(
        conConfig.txConf as AddDevType.TxConf_JSON
      )
    } else {
      devCon.paramConfList = devTypeModuleMODBUSTxConf2devMODBUSConf(
        conConfig.txConf as AddDevType.TxConf_MODBUS[]
      )
    }

    return devCon
  }

  function devTypeModuleJSONTxConf2devJSONConf(
    txConf: AddDevType.TxConf_JSON
  ): Device.ParamConfJSON[] {
    let devJSONConf: Device.ParamConfJSON = {
      devId: txConf.devTypeId,
      jdtParamConfDesc: txConf.jdtParamConfDesc,
      confId: txConf.confId,
      jdtParamConfFlag: txConf.jdtParamConfFlag,
      sort: txConf.sort,
      paramConfDataList: txConf.paramConfDataList
    }

    return [devJSONConf]
  }

  function devTypeModuleMODBUSTxConf2devMODBUSConf(
    txConfList: AddDevType.TxConf_MODBUS[]
  ): Device.ParamConfMODBUS[] {
    let devMODBUSConfList: Device.ParamConfMODBUS[] = []

    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]
      let devModBusConf: Device.ParamConfMODBUS = {
        confId: txConf.confId,
        devId: txConf.devTypeId,
        mdtParamConfDesc: txConf.mdtParamConfDesc,
        addressCode: txConf.addressCode,
        funCode: txConf.funCode,
        sort: txConf.sort,
        paramConfDataList: txConf.paramConfDataList
      }

      devMODBUSConfList.push(devModBusConf)
    }
    return devMODBUSConfList
  }

  //----------------------------------- JSON监测参数列表 操作属性 处理 -----------------------------------

  /**
   *
   * @param defaultTxConf 原始 JSON协议 监测参数列表
   * @param txConf 组件 JSON协议 监测参数列表
   * @returns
   */
  function handleMakePropertyByJSONConConf(
    defaultTxConf: AddDevType.TxConf_JSON<AddDevType.ParamConfData_JSON>,
    txConf: EditDevConConfigOptionParamConfJSON
  ) {
    // 原始的JSON协议配置监测参数列表
    let defaultParamConfDataList = defaultTxConf.paramConfDataList

    // 组件的JSON协议配置监测参数列表
    let paramConfDataList = txConf.paramConfDataList

    // 配置没有confId，会出现在以下情况中出现
    // 1. 添加设备类型的时候未配置通信协议
    if (!txConf.confId) {
      txConf.makeProperty = 'add'
      if (!txConf.paramConfDataList.length) {
        message.warning('请添加参数')
        return undefined
      }

      for (let i = 0; i < txConf.paramConfDataList.length; i++) {
        const paramConfData = txConf.paramConfDataList[i]
        paramConfData.confId = txConf.confId

        let flag = JSONParamConfDataIsOk(paramConfData)
        if (!flag) {
          return undefined
        }
        paramConfData.makeProperty = 'add'
      }
    } else {
      // 存在对应的JSON协议配置时

      // 将JSON协议配置的操作属性设为空
      txConf.makeProperty = ''

      // 判断操作属性是添加（add）、修改(edit)
      for (let i = 0; i < paramConfDataList.length; i++) {
        // 组件的JSON协议配置监测参数
        const paramConfData = paramConfDataList[i]
        paramConfData.confId = txConf.confId

        // 校验JSON协议的参数配置是否完整
        // 校验内自带错误提示
        let flag = JSONParamConfDataIsOk(paramConfData)
        if (!flag) {
          return undefined
        }

        // 初始将JSON协议的所有参数的操作属性改为空字符
        paramConfData.makeProperty = ''

        // 在 defaultParamConfDataIndex 中查询是否存在与paramConfData.confDataId相同的项
        const defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
          item => item.confDataId === paramConfData.confDataId
        )

        /**如果有值 比对必要属性是否相同 */
        if (defaultParamConfDataIndex !== -1) {
          // 原始的JSON配置监测参数
          const defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

          let flag = JSONParamConfDataIsDiff(defaultParamConfData, paramConfData)
          if (flag) {
            // 如果不同将操纵属性改为edit
            paramConfData.makeProperty = 'edit'
            txConf.makeProperty = 'edit'
          }
        } else {
          // 如果没值 视为添加
          paramConfData.makeProperty = 'add'
          txConf.makeProperty = 'edit'
        }
      }

      // 处理删除掉的参数
      for (let i = 0; i < defaultParamConfDataList.length; i++) {
        // 原始的JSON配置监测参数
        const defaultParamConfData = defaultParamConfDataList[i]

        // 在组件的监测参数列表中查询不到时
        let paramConfDataIndex = paramConfDataList.findIndex(
          item => item.confDataId === defaultParamConfData.confDataId
        )

        // paramConfDataIndex为-1 表示用户已将此参数删除
        if (paramConfDataIndex === -1) {
          //! 这里的判断只是做一个验证
          // 一般来说defaultParamConfData里面所有的数据都是完整的
          // 组件中是将其直接从数组中删除掉
          // 所以这里要将数据加回来，发给后端在数据库中删除
          if (defaultParamConfData.confId && defaultParamConfData.confDataId) {
            paramConfDataList.push({
              confId: defaultParamConfData.confId,
              confDataId: defaultParamConfData.confDataId,
              paramCode: defaultParamConfData.paramCode,
              paramName: defaultParamConfData.paramName,
              paramDesc: defaultParamConfData.paramDesc,
              reserveNum: defaultParamConfData.reserveNum,
              sort: defaultParamConfData.sort,
              makeProperty: 'delete'
            })
          }
        }
      }
    }
  }

  //----------------------------------- MODBUS数据集 操作属性 处理 -----------------------------------

  /**
   *
   * @param defaultTxConfList 原始 MODBUS协议 参数集
   * @param txConfList 组件 MODBUS协议 参数集
   * @returns
   */
  function handleMakePropertyByMODBUSConConfList(
    defaultTxConfList: AddDevType.TxConf_MODBUS<AddDevType.ParamConfData_MODBUS>[],
    txConfList: EditDevConConfigOptionParamConfMODBUS[]
  ) {
    // 处理参数集
    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]

      let isOk = MODBUSTxConfDataIsOk(txConf)

      if (!isOk) return undefined

      let defaultTxConfIndex = defaultTxConfList.findIndex(item => item.confId === txConf.confId)

      let defaultTxConf = defaultTxConfList[defaultTxConfIndex]

      if (!defaultTxConf) {
        // 原始参数集中没有对应的数据集，视为添加
        txConf.makeProperty = 'add'

        // 数据集添加时，内部所有参数的操作属性都为添加
        for (let j = 0; j < txConf.paramConfDataList.length; j++) {
          const paramConfData = txConf.paramConfDataList[j]
          paramConfData.makeProperty = 'add'
        }
      } else {
        let flag = MODBUSTxConfDataIsDiff(defaultTxConf, txConf)

        if (flag) txConf.makeProperty = 'edit'

        handleMakePropertyByMODBUSConConfDataList(defaultTxConf, txConf)
      }
    }

    // 处理删除掉的参数集
    for (let i = 0; i < defaultTxConfList.length; i++) {
      const defaultTxConf = defaultTxConfList[i]

      let txConfIndex = txConfList.findIndex(item => item.confId === defaultTxConf.confId)

      // txConfIndex为-1 表示用户已将此参数集删除
      if (txConfIndex === -1) {
        if (defaultTxConf.confId && defaultTxConf.devTypeId) {
          txConfList.push({
            addressCode: defaultTxConf.addressCode,
            funCode: defaultTxConf.funCode,
            confId: defaultTxConf.confId,
            devId: defaultTxConf.devTypeId,
            sort: defaultTxConf.sort,
            mdtParamConfDesc: defaultTxConf.mdtParamConfDesc,
            makeProperty: 'delete',
            paramConfDataList:
              defaultTxConf.paramConfDataList.map<EditDevConConfigOptionParamConfDataMODBUS>(
                item => ({
                  confId: item.confId,
                  confDataId: item.confDataId,
                  paramCode: item.paramCode,
                  dataType: item.dataType,
                  startHexStr: item.startHexStr,
                  numMade: item.numMade,
                  reserveNum: Number(item.reserveNum),
                  byteType: item.byteType,
                  paramName: item.paramName,
                  paramDesc: item.paramDesc,
                  sort: item.sort,
                  makeProperty: 'delete'
                })
              )
          })
        }
      }
    }
  }

  //----------------------------------- MODBUS监测参数列表 操作属性 处理 -----------------------------------
  /**
   *
   * @param defaultTxConf 原始 MODBUS协议 监测参数列表
   * @param txConf 组件 MODBUS协议 监测参数列表
   * @returns
   */
  function handleMakePropertyByMODBUSConConfDataList(
    defaultTxConf: AddDevType.TxConf_MODBUS<AddDevType.ParamConfData_MODBUS>,
    txConf: EditDevConConfigOptionParamConfMODBUS
  ) {
    let defaultParamConfDataList = defaultTxConf.paramConfDataList

    let paramConfDataList = txConf.paramConfDataList

    for (let j = 0; j < paramConfDataList.length; j++) {
      const paramConfData = paramConfDataList[j]
      let flag = MODBUSParamConfDataIsOk(paramConfData)

      if (!flag) {
        return
      }
      /**
       * 初始将MODBUS所有参数的操作属性改为delete
       *
       * 通过后续对比 在更改为edit add 或者 空字符
       */
      let defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
        item => item.confDataId === paramConfData.confDataId
      )
      let defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

      if (!defaultParamConfData) {
        paramConfData.makeProperty = 'add'
      } else {
        let flag = MODBUSParamConfDataIsDiff(defaultParamConfData, paramConfData)

        if (flag) {
          // 如果不同将操纵属性改为edit
          paramConfData.makeProperty = 'edit'
        } else {
          // 如果相同操纵属性改为空字符
          paramConfData.makeProperty = ''
        }
      }
    }

    // 处理删除掉的参数
    for (let i = 0; i < defaultParamConfDataList.length; i++) {
      const defaultParamConfData = defaultParamConfDataList[i]

      let paramConfDataIndex = paramConfDataList.findIndex(
        item => item.confDataId === defaultParamConfData.confDataId
      )
      // paramConfDataIndex为-1 表示用户已将此参数删除
      if (paramConfDataIndex === -1) {
        if (defaultParamConfData.confId && defaultParamConfData.confDataId) {
          paramConfDataList.push({
            confId: defaultParamConfData.confId,
            confDataId: defaultParamConfData.confDataId,
            paramCode: defaultParamConfData.paramCode,
            paramName: defaultParamConfData.paramName,
            paramDesc: defaultParamConfData.paramDesc,
            reserveNum: Number(defaultParamConfData.reserveNum),
            sort: defaultParamConfData.sort,
            dataType: defaultParamConfData.dataType,
            startHexStr: defaultParamConfData.startHexStr,
            numMade: defaultParamConfData.numMade,
            byteType: defaultParamConfData.byteType,
            makeProperty: 'delete'
          })
        }
      }
    }
  }

  // ----------------------------------- 数据校验 -----------------------------------

  /**
   * 传入两个JSON协议的检测参数配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function JSONParamConfDataIsDiff(
    defaultData: AddDevType.ParamConfData_JSON,
    currentData: AddDevType.ParamConfData_JSON
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.confDataId !== currentData.confDataId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramCode !== currentData.paramCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramDesc !== currentData.paramDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.reserveNum != currentData.reserveNum) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramName !== currentData.paramName) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    return false
  }

  /**
   * 传入JSON协议的检测参数配置，查看数据是否完整
   *
   * @return boolean  true:完整 false:不完整
   *  */
  function JSONParamConfDataIsOk(data: AddDevType.ParamConfData_JSON): boolean {
    // confId无需校验
    // if (!data.confId) {
    //   console.error(data)

    //   return false
    // }

    if (!data.paramCode) {
      console.error(data)
      message.warning('请选择监测参数')
      return false
    }

    if (!data.sort) {
      console.error(data)
      return false
    }

    let reserveNum = Number(data.reserveNum)
    if (isNaN(reserveNum)) {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    if (data.reserveNum === '') {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    // 不用判断检测参数名称
    // 选择的时候会自动赋值
    // if (!data.paramName) {
    //   console.error(data)
    //   return false
    // }

    return true
  }

  /**
   * 传入两个MODBUS协议的检测参数配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function MODBUSParamConfDataIsDiff(
    defaultData: AddDevType.ParamConfData_MODBUS,
    currentData: EditDevConConfigOptionParamConfDataMODBUS
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.confDataId !== currentData.confDataId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramCode !== currentData.paramCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramName !== currentData.paramName) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.reserveNum != currentData.reserveNum) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.byteType !== currentData.byteType) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.dataType !== currentData.dataType) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.startHexStr !== currentData.startHexStr) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.numMade !== currentData.numMade) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramDesc !== currentData.paramDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }

    return false
  }

  /**
   * 传入两个MODBUS协议的通信配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function MODBUSTxConfDataIsDiff(
    defaultData: AddDevType.TxConf_MODBUS,
    currentData: EditDevConConfigOptionParamConfMODBUS
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.devTypeId !== currentData.devId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.funCode !== currentData.funCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (currentData.paramConfDataList.length === 0) {
      message.error('有参数集的监测参数为空')
      return true
    }
    if (defaultData.addressCode !== currentData.addressCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.mdtParamConfDesc !== currentData.mdtParamConfDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    return false
  }

  /**
   * 传入MODBUS协议的通信配置，检测数据是否完整
   *
   * @return boolean  true:完整 false: 不完整
   *  */
  function MODBUSTxConfDataIsOk(data: EditDevConConfigOptionParamConfMODBUS): boolean {
    // confId无需校验
    // if (!data.confId) {
    //   console.error(data)
    //   return false
    // }

    if (!data.addressCode) {
      console.error(data)
      message.warning('请485地址')

      return false
    }

    if (!data.funCode) {
      console.error(data)
      message.warning('请功能码')
      return false
    }

    return true
  }

  /**
   * 传入MODBUS协议的参数配置，检测数据是否完整
   *
   * @return boolean  true:完整 false: 不完整
   *  */
  function MODBUSParamConfDataIsOk(data: EditDevConConfigOptionParamConfDataMODBUS): boolean {
    // confDataId无需校验
    // if (!data.confDataId) {
    //   console.error(data)
    //   return false
    // }

    if (!data.paramCode) {
      console.error(data)
      message.warning('请选择监测参数')

      return false
    }

    let reserveNum = Number(data.reserveNum)
    if (isNaN(reserveNum)) {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    if (!data.startHexStr) {
      console.error(data)
      message.warning('请输入起始位')
      return false
    }

    if (data.startHexStr.length !== 4) {
      console.error(data)
      message.warning('起始位长度必须为4')
      return false
    }

    return true
  }
  //-----------------------------------处理devConConfig的操作属性（makeProperty）-----------------------------------
  const getDevModuleConConfigOperatingrecord = computed<EditDevConConfigOption | undefined>(() => {
    if (!devConConfig.value.devId) {
      return undefined
    }

    if (!devTypeModuleConConfig.value.devTypeId) {
      return undefined
    }

    /**
     * 将 AddDevType.DevTypeConConfigSign 转为 EditdevConConfigOption
     *
     * 方便添加makeProperty
     *  */
    let returnData: EditDevConConfigOption | undefined = undefined

    // JSON协议处理
    if (devConConfig.value.devDataTypeCode === '0019') {
      // 获取原始数据
      let defaultModuleConConfig = devConConfig2devTypeModuleConConfig(
        deepClone(devConConfig.value),
        false
      ) as AddDevType.DevTypeConConfigSign<AddDevType.TxConf_JSON>

      let defaultTxConf = defaultModuleConConfig.txConf

      /**组件的JSON协议配置 */
      let moduleConConfig = deepClone(
        devTypeModuleConConfig.value
      ) as AddDevType.DevTypeConConfigSign<EditDevConConfigOptionParamConfJSON>

      let txConf = moduleConConfig.txConf

      handleMakePropertyByJSONConConf(defaultTxConf, txConf)

      returnData = {
        devCCId: moduleConConfig.devTypeCCId,
        devId: moduleConConfig.devTypeId,
        devTxTypeCode: moduleConConfig.devTypeTxTypeCode,
        devDataTypeCode: moduleConConfig.devTypeDataTypeCode,
        devHeart: moduleConConfig.devTypeHeart,
        paramConfList: [moduleConConfig.txConf]
      }
    } else {
      // MODBUS协议处理

      // 获取原始数据
      let defaultModuleConConfig = devConConfig2devTypeModuleConConfig(
        devConConfig.value,
        false
      ) as AddDevType.DevTypeConConfigSign<AddDevType.TxConf_MODBUS[]>

      // 原始参数集
      let defaultTxConfList = defaultModuleConConfig.txConf

      // 组件参数集
      let moduleConConfig = deepClone(
        devTypeModuleConConfig.value
      ) as AddDevType.DevTypeConConfigSign<EditDevConConfigOptionParamConfMODBUS[]>

      // 组件参数集
      let txConfList = moduleConConfig.txConf

      handleMakePropertyByMODBUSConConfList(defaultTxConfList, txConfList)

      returnData = {
        devCCId: moduleConConfig.devTypeCCId,
        devId: moduleConConfig.devTypeId,
        devTxTypeCode: moduleConConfig.devTypeTxTypeCode,
        devDataTypeCode: moduleConConfig.devTypeDataTypeCode,
        devHeart: moduleConConfig.devTypeHeart,
        paramConfList: moduleConConfig.txConf
      }
    }

    return returnData
  })

  return {
    devConConfig,
    devTypeModuleConConfig,
    devConConfig2devTypeModuleConConfig,
    initDevConConfig,
    getDevModuleConConfigOperatingrecord
  }
}

export default useDevConConfig
